package com.berchen.闭锁;

import java.util.concurrent.CountDownLatch;

/**
 * CountDownLatch 闭锁：在完成某些运算时，只有其他所有线程的全部运算全部完成，当前运算才会执行。
 *
 * 计算十个线程执行的时间：十个线程都是并发操作的，不能直接计算运行的时间。所以这里就用到了闭锁来计算。
 */
public class TestCountDownLatch {

    public static void main(String[] args){

        final CountDownLatch latch=new CountDownLatch(10);

        LatchThread ld=new LatchThread(latch);

        long start=System.currentTimeMillis();  // 线程开始执行时间
        for(int i=0;i<10;i++){

            new Thread(ld).start();
        }

        try{

            latch.await();  // 如果初始化参数没有减为0，那么这后面的代码就一直等待。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end=System.currentTimeMillis();    // 线程结束时间。

        // 这里并算不出来十个线程的时间，因为main也是一个线程，就是十一个线程同时抢夺CPU的资源。十一个线程是并发的。我们想要的是十个线程执行完成才执行这个end 和这个输出语句
        System.out.println("十个线程耗时时间："+(end-start));

    }
}

class LatchThread implements Runnable {

    private CountDownLatch latch;

    public LatchThread(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void run() {

        synchronized (this){

            try {
                for (int i = 0; i < 50000; i++) {

                    if (i % 2 == 0) {
                        System.out.println(i);
                    }
                }
            }
            finally {   // 这里使用finally是因为必须要让初始化参数减1.
                latch.countDown();  // 将CountDownLatch初始化传递的参数减去1。只有当初始化参数减成0时才可以执行其他的操作。
            }
        }
    }
}
